package com.briup.bookstore.common.util;

import com.briup.bookstore.common.exception.CustomException;
import com.briup.bookstore.common.response.ResultCode;
import org.springframework.beans.BeanUtils;
import org.springframework.util.StringUtils;

import java.util.Collection;

/**
 * 工具类 - 处理对象相关
 *
 * @author YuYan
 */
public class ObjectUtil {

    /**
     * 忽略大小写判断两字符串内容是否相同
     *
     * @param s1
     * @param s2
     * @return
     */
    public static boolean equalsIgnoreCase(String s1, String s2) {
        return !isNull(s1) && s1.equalsIgnoreCase(s2);
    }

    /**
     * 判断多个字符串中是否有任意一个为空
     * 1）为null值
     * 2）为""串
     * 3）为完全由空白字符构成的字符串
     *
     * @param strs
     * @return 如果可变参数组中有至少一个为空或空白内容的字符串就会返回true，
     * 所有的参数都不为空，则返回false
     */
    public static boolean anyNotHasText(String... strs) {
        if (ObjectUtil.isNull(strs)) {
            return true;
        }
        for (String str : strs) {
            if (notHasText(str)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断指定字符串是否包含有效文本
     * 条件如下：
     * 1）值不能为null
     * 2）值不能为""
     * 3）值不能为纯空白字符构成的字符串（空白字符即空格、回车、换行、制表符）
     *
     * @param s
     * @return 同时满足上述三个条件返回true，否则返回false
     */
    public static boolean hasText(String s) {
        return StringUtils.hasText(s);
    }

    /**
     * 判断指定字符串是否不包含有效文本
     * 条件如下：
     * 1）值为null
     * 2）值为""
     * 3）值为纯空白字符构成的字符串（空白字符即空格、回车、换行、制表符）
     *
     * @param str
     * @return 满足上述三个条件任意一个则返回true，否则返回false
     */
    public static boolean notHasText(String str) {
        return !StringUtils.hasText(str);
    }


    /**
     * 判断两字符串内容是否相同
     *
     * @param s1
     * @param s2
     * @return
     */
    public static boolean equals(String s1, String s2) {
        if (s1 == null) {
            return false;
        }
        return s1.equals(s2);
    }

    /**
     * 判断两字符串值是否不同
     *
     * @param s1
     * @param s2
     * @return
     */
    public static boolean notEquals(String s1, String s2) {
        return !equals(s1, s2);
    }


    /**
     * 判断两对象是否相同
     *
     * @param o1
     * @param o2
     * @return
     */
    public static boolean equals(Object o1, Object o2) {
        /* 如果两个对象的地址已经相同，则直接返回true */
        if (o1 == o2) {
            return true;
        }
        /* 如果o1为null，则直接返回false（因为o2不可能也为null） */
        if (isNull(o1)) {
            return false;
        }
        return o1.equals(o2);
    }

    /**
     * 判断两对象是否不同
     *
     * @param o1
     * @param o2
     * @return
     */
    public static boolean notEquals(Object o1, Object o2) {
        return !equals(o1, o2);
    }

    /**
     * 判断某个对象是否为空指针
     *
     * @param obj
     * @return
     */
    public static boolean isNull(Object obj) {
        return obj == null;
    }

    /**
     * 判断某个对象是否不为空指针
     *
     * @param obj
     * @return
     */
    public static boolean nonNull(Object obj) {
        return !isNull(obj);
    }

    /**
     * 判断传入的对象是否为空
     *
     * @return
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.size() == 0;
    }

    /**
     * 判断传入的对象是否为空
     *
     * @return
     */
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        if (obj.getClass().isArray()) {
            return ((Object[]) obj).length == 0;
        }
        return false;
    }

    /**
     * 判断传入的对象是否不为空
     *
     * @return
     */
    public static boolean nonEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }

    /**
     * 判断传入的对象是否不为空
     *
     * @return
     */
    public static boolean nonEmpty(Object obj) {
        return !isEmpty(obj);
    }

    public static void copyProperties(Object source, Object target) {
        BeanUtils.copyProperties(source, target);
    }

    public static <T> T copyProperties(Object source, Class<T> poType) {
        if (ObjectUtil.isNull(source)) {
            return null;
        }
        try {
            /* 通过反射机制创建目标对象 */
            T target = poType.newInstance();
            /* 从源对象中复制属性到目标对象中 */
            BeanUtils.copyProperties(source, target);
            return target;
        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomException(ResultCode.SYSTEM_INNER_ERROR);
        }

    }


}
